home *** CD-ROM | disk | FTP | other *** search
/ Just Call Me Internet / Just Call Me Internet.iso / prog / atari / c / nos042_s / ksubr.c < prev    next >
C/C++ Source or Header  |  1994-09-16  |  7KB  |  247 lines
  1. #include <stdio.h>    /***/
  2. #include <dos.h>
  3. #include <setjmp.h>
  4. /*
  5.     Machine or compiler-dependent portions of kernel
  6.     Atari ST / Lattice C 5.5 version - DFN
  7. */
  8.  
  9. #include "global.h"
  10. #include "proc.h"
  11. #include "commands.h"
  12.  
  13. static unsigned short oldNull;
  14. static unsigned short *oldNullp;
  15. static int  stkutil(struct proc *pp);
  16.        void init_psetup(struct proc *pp);
  17.        
  18. struct JMP_BUF {
  19.         int    jmp_d2;
  20.         int    jmp_d3;
  21.         int    jmp_d4;
  22.         int    jmp_d5;
  23.         int    jmp_d6;
  24.         int    jmp_d7;  
  25.         int    jmp_pc;
  26.         int    jmp_a2;
  27.         int    jmp_a3;
  28.         int    jmp_a4;
  29.         int    jmp_a5;
  30.         int    jmp_a6;
  31.         int    jmp_a7;
  32.         };
  33.   
  34. void kinit(void)
  35. {
  36.     /* Remember location 0 pattern to detect null pointer derefs */
  37. #ifndef ATARI           /* Access to location 0 causes bus error on ATARI */
  38.     oldNullp = NULL;
  39.     oldNull = *oldNullp;
  40. #endif
  41. }
  42.  
  43.  
  44. /* Print process table info
  45.  * Since things can change while ps is running, the ready proceses are
  46.  * displayed last. This is because an interrupt can make a process ready,
  47.  * but a ready process won't spontaneously become unready. Therefore a
  48.  * process that changes during ps may show up twice, but this is better
  49.  * than not having it showing up at all.
  50.  */
  51. int
  52. ps(int argc, char *argv[], void *p)
  53. {
  54.     register struct proc *pp;
  55.     register struct JMP_BUF *ep;
  56.     unsigned short i;
  57.  
  58.     tprintf("PID       SP        stksize   maxstk    event     fl  in out name\n");
  59.  
  60.     for(pp = Susptab;pp != NULLPROC;pp = pp->next){
  61.         ep = (struct JMP_BUF *)&pp->env;
  62.         if(tprintf("%-10lx%-10lx%-10u%-10u%-10lx%c%c%c %2d %2d  %s\n",
  63.          pp,                /* process */
  64.          ep->jmp_a7,            /* stack pointer */
  65.          pp->stksize,            /* stack size */
  66.          stkutil(pp),            /* maxstk */
  67.          pp->event,            /* event */
  68.          pp->i_state ? 'I' : ' ',    /* flags */
  69.          (pp->state & WAITING) ? 'W' : ' ',
  70.          (pp->state & SUSPEND) ? 'S' : ' ',
  71.          pp->input, pp->output,        /* input, output sockets */
  72.          pp->name) == EOF)        /* name */
  73.             return 0;
  74.     }
  75.  
  76.     for(i=0;i<PHASH;i++){
  77.         for(pp = Waittab[i];pp != NULLPROC;pp = pp->next){
  78.             ep = (struct JMP_BUF *)&pp->env;
  79.             if(tprintf("%-10lx%-10lx%-10u%-10u%-10lx%c%c%c %2d %2d  %s\n",
  80.              pp,            /* process */
  81.              ep->jmp_a7,            /* stack pointer */
  82.              pp->stksize,            /* stack size */
  83.              stkutil(pp),            /* maxstk */
  84.              pp->event,            /* event */
  85.              pp->i_state ? 'I' : ' ',    /* flags */
  86.              (pp->state & WAITING) ? 'W' : ' ',
  87.              (pp->state & SUSPEND) ? 'S' : ' ',
  88.              pp->input, pp->output,
  89.              pp->name) == EOF)        /* name */
  90.                 return 0;
  91.         }
  92.     }
  93.  
  94.     for(pp = Rdytab;pp != NULLPROC;pp = pp->next){
  95.         ep = (struct JMP_BUF *)&pp->env;
  96.         if(tprintf("%-10lx%-10lx%-10u%-10u%-10lx%c%c%c %2d %2d  %s\n",
  97.          pp,            /* process */
  98.          ep->jmp_a7,            /* stack pointer */
  99.          pp->stksize,            /* stack size */
  100.          stkutil(pp),            /* maxstk */
  101.          pp->event,            /* event */
  102.          pp->i_state ? 'I' : ' ',    /* flags */
  103.          (pp->state & WAITING) ? 'W' : ' ',
  104.          (pp->state & SUSPEND) ? 'S' : ' ',
  105.          pp->input, pp->output,
  106.          pp->name) == EOF)        /* name */
  107.             return 0;
  108.     }
  109.  
  110.     if(Curproc != NULLPROC){
  111.         pp = Curproc;
  112.         if(tprintf("%-10lx%-10lx%-10u%-10u%-10lx%c%c%c %2d %2d  %s\n",
  113.          pp,            /* process */
  114.          ep->jmp_a7,            /* stack pointer */
  115.          pp->stksize,            /* stack size */
  116.          stkutil(pp),            /* maxstk */
  117.          pp->event,            /* event */
  118.          pp->i_state ? 'I' : ' ',    /* flags */
  119.          (pp->state & WAITING) ? 'W' : ' ',
  120.          (pp->state & SUSPEND) ? 'S' : ' ',
  121.          pp->input, pp->output,
  122.          pp->name) == EOF)        /* name */
  123.             return 0;
  124.     }
  125.     return 0;
  126. }
  127.  
  128. int stkutil(struct proc *pp)
  129. {
  130.     unsigned int i;
  131.     int16 *sp;
  132.  
  133.     i = pp->stksize;
  134.     for(sp = pp->stack;*sp == STACKPAT && sp < pp->stack + pp->stksize;sp++)
  135.         i--;
  136.     return (int) i;
  137. }
  138.  
  139. /* Verify that stack pointer for current process is within legal limits;
  140.  * also check that no one has dereferenced a null pointer
  141.  */
  142. void
  143. chkstk(void)
  144. {
  145.     int16 *sbase;
  146.     int16 *stop;
  147.     int16 *sp = (int16 *) getreg(REG_A7);  /* get current stack pointer */
  148.                       /* this is Lattice C 5.0 specific */
  149.  
  150.     sbase = Curproc->stack;
  151.     stop = sbase + Curproc->stksize;
  152.     if(sp < sbase || sp >= stop){
  153.         printf("Stack violation, process %s \n\n",Curproc->name);
  154.         printf("SP = %lx, legal stack range [%lx,%lx) \n\n",
  155.             sp, sbase, stop);
  156.         fflush(stdout);
  157.         killself();
  158.     }
  159. #ifndef ATARI    
  160.     if(*oldNullp != oldNull){
  161.         printf("WARNING: Location 0 smashed, process %s\n",Curproc->name);
  162.         *oldNullp = oldNull;
  163.         fflush(stdout);
  164.     }
  165. #endif
  166. }
  167.  
  168. /* Machine-dependent initialization of the initial task */
  169. void
  170. init_psetup(pp)
  171.     struct proc *pp;
  172. {
  173.     /*
  174.      *  The base of the stack that's allocated to this program by the
  175.      *  Amiga operating system has been left for us in "base" by the
  176.      *  C startup routine.  
  177.      */
  178.     extern int16 *_base;
  179.     register int i;
  180.  
  181.     pp->stack = _base;
  182.     pp->stksize = (int16 *)getreg(REG_A7) - pp->stack;
  183.     /*
  184.      *  Have to be careful here to only clear as much of the stack as we're 
  185.      *  not currently using.
  186.      */
  187.  
  188.     for (i=0; i<pp->stksize; i++)
  189.         pp->stack[i] = STACKPAT;
  190.  
  191.     pp->stksize += 50;    /* slop.. there is a way to find out what this
  192.                    really is. */
  193.     setjmp(pp->env);
  194.     pp->i_state = 1;
  195. }
  196.  
  197.  
  198. /* Machine-dependent initialization of a task */
  199. void
  200. psetup(pp,iarg,parg1,parg2,pc)
  201. struct proc *pp;    /* Pointer to task structure */
  202. int iarg;        /* Generic integer arg */
  203. void *parg1;        /* Generic pointer arg #1 */
  204. void *parg2;        /* Generic pointer arg #2 */
  205. void (*pc)();        /* Initial execution address */
  206. {
  207.     register long *stktop;
  208.     register struct JMP_BUF *ep;
  209.  
  210.     /* Set up stack to make it appear as if the user's function was called
  211.      * by killself() with the specified arguments. When the user returns,
  212.      * killself() automatically cleans up.
  213.      *
  214.      * First, push args on stack in reverse order, simulating what C
  215.      * does just before it calls a function.
  216.      */
  217.     stktop = (long *)(pp->stack + pp->stksize);
  218.  
  219.     /* NOTE:  this only works when compiled with 32 bit integers */
  220.     *--stktop = (long) parg2;
  221.     *--stktop = (long) parg1;
  222.     *--stktop = (long) iarg;
  223.         
  224.     /* Now push the entry address of killself(), simulating the call to
  225.      * the user function.
  226.      */
  227.     *--stktop = (long) killself;
  228.  
  229. /*    *--stktop = 0;    */    /* fodder for longjmp() */
  230.  
  231.     setjmp(pp->env);
  232.     ep = (struct JMP_BUF *)&pp->env;
  233.  
  234.     ep->jmp_a7 = (long) stktop;
  235.     ep->jmp_pc = (long) pc;
  236.     ep->jmp_a4 = getreg(REG_A4);/* set-up base relative addressing
  237.                        environment pointer */
  238. /*    ep->jmp_d1 = (long) iarg;  */
  239. /*    ep->jmp_a1 = (long) parg1; */
  240.     ep->jmp_a2 = (long) parg2;
  241.     ep->jmp_a3 = (long) pp;
  242.  
  243.     /* Task initially runs with interrupts on */
  244.     pp->i_state = 1;
  245. }
  246.  
  247.